package org.example.scoresystem_backen.controller;

import org.example.scoresystem_backen.common.Result;
import org.example.scoresystem_backen.entity.Class;
import org.example.scoresystem_backen.dto.ClassOptionDTO;
import org.example.scoresystem_backen.dto.PageRequest;
import org.example.scoresystem_backen.dto.PageResponse;
import org.example.scoresystem_backen.service.ClassService;
import org.example.scoresystem_backen.util.AuthUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 班级控制器
 * 实现班级管理的CRUD操作，支持分页查询、搜索筛选和级联删除
 */
@RestController
@RequestMapping("/api/classes")
@CrossOrigin(origins = "*")
public class ClassController {

    @Autowired
    private ClassService classService;
    
    // ========== 分页查询接口 ==========

    /**
     * 获取班级列表（支持分页、搜索、筛选）
     * @param page 页码（默认1）
     * @param pageSize 每页条数（默认10，最大100）
     * @param search 搜索关键词（按班级名称模糊查询）
     * @param grade 年级筛选
     * @return 分页响应结果
     */
    @GetMapping
    public Result<PageResponse<Class>> getClasses(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10", name = "page_size") Integer pageSize,
            @RequestParam(required = false) String search,
            @RequestParam(required = false) String grade) {
        try {
            // 权限检查：需要登录
            Integer currentUserId = AuthUtil.getCurrentUserId();
            if (currentUserId == null) {
                return Result.error("访问被拒绝，请先登录");
            }

            // 构建分页请求
            PageRequest pageRequest = new PageRequest();
            pageRequest.setPage(page);
            pageRequest.setPageSize(pageSize);
            pageRequest.setSearch(search);

            PageResponse<Class> response = classService.findClassesWithPagination(pageRequest, grade);
            return Result.success("获取班级列表成功", response);
        } catch (Exception e) {
            return Result.error("获取班级列表失败: " + e.getMessage());
        }
    }

    // ========== CRUD操作接口 ==========

    /**
     * 添加班级
     * @param clazz 班级信息
     * @return 创建结果
     */
    @PostMapping
    public Result<Class> addClass(@RequestBody Class clazz) {
        try {
            // 权限检查：需要登录
            Integer currentUserId = AuthUtil.getCurrentUserId();
            if (currentUserId == null) {
                return Result.error("访问被拒绝，请先登录");
            }

            // 数据验证
            if (clazz.getName() == null || clazz.getName().trim().isEmpty() ||
                clazz.getGrade() == null || clazz.getGrade().trim().isEmpty()) {
                return Result.error("数据验证失败，班级名称和年级为必填项");
            }

            Class createdClass = classService.createClass(clazz);
            return Result.success("班级添加成功", createdClass);
        } catch (Exception e) {
            return Result.error("添加班级失败: " + e.getMessage());
        }
    }

    /**
     * 更新班级信息
     * @param id 班级ID
     * @param clazz 班级信息
     * @return 更新结果
     */
    @PutMapping("/{id}")
    public Result<Class> updateClass(@PathVariable Integer id, @RequestBody Class clazz) {
        try {
            // 权限检查：需要登录
            Integer currentUserId = AuthUtil.getCurrentUserId();
            if (currentUserId == null) {
                return Result.error("访问被拒绝，请先登录");
            }

            // 数据验证
            if (clazz.getName() == null || clazz.getName().trim().isEmpty() ||
                clazz.getGrade() == null || clazz.getGrade().trim().isEmpty()) {
                return Result.error("数据验证失败，班级名称和年级为必填项");
            }

            // 设置ID
            clazz.setId(id);
            Class updatedClass = classService.updateClass(clazz);
            return Result.success("班级更新成功", updatedClass);
        } catch (Exception e) {
            return Result.error("更新班级失败: " + e.getMessage());
        }
    }
    
    /**
     * 删除班级（级联删除相关学生和成绩记录）
     * @param id 班级ID
     * @return 删除结果
     */
    @DeleteMapping("/{id}")
    public Result<Map<String, Object>> deleteClass(@PathVariable Integer id) {
        try {
            // 权限检查：需要登录
            Integer currentUserId = AuthUtil.getCurrentUserId();
            if (currentUserId == null) {
                return Result.error("访问被拒绝，请先登录");
            }

            Map<String, Object> deleteResult = classService.deleteClassWithCascade(id);

            // 构建删除消息
            String message = "班级删除成功";
            Integer deletedStudentsCount = (Integer) deleteResult.get("deleted_students_count");
            Integer deletedScoresCount = (Integer) deleteResult.get("deleted_scores_count");

            if (deletedStudentsCount > 0) {
                message += "，同时删除了 " + deletedStudentsCount + " 名学生";
            }
            if (deletedScoresCount > 0) {
                message += "和 " + deletedScoresCount + " 条成绩记录";
            }

            return Result.success(message, deleteResult);
        } catch (Exception e) {
            return Result.error("删除班级失败: " + e.getMessage());
        }
    }

    // ========== 辅助数据接口 ==========

    /**
     * 获取班级选项列表（用于下拉选择）
     * 注意：此接口不需要认证，用于注册页面获取班级列表
     * @return 班级选项列表
     */
    @GetMapping("/options")
    public Result<List<ClassOptionDTO>> getClassOptions() {
        try {
            // 此接口不需要权限检查，允许未登录用户访问（用于注册页面）
            List<Class> classes = classService.findAll();
            List<ClassOptionDTO> options = classes.stream()
                    .map(ClassOptionDTO::new)
                    .collect(Collectors.toList());
            return Result.success("获取班级选项成功", options);
        } catch (Exception e) {
            return Result.error("获取班级选项失败: " + e.getMessage());
        }
    }
}
